home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / GNU_C++ / LIB / SRC / GEMLIB38.LZH / v_escape.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-07-10  |  12.2 KB  |  624 lines
  1. /*
  2.  * vdiesc.c
  3.  * Copyright 1991 Jens Tingleff (uunet!titan.ee.ic.ac.uk!jensting)
  4.  * Dedicated to public domain
  5.  *
  6.  * -------------------------------------
  7.  * 12.07.97 cf (felsch@tu-harburg.de)
  8.  *        modified for new control arrays
  9.  *
  10.  * 15.06.98
  11.  *        - restructured, new bindings for all functions
  12. */
  13.  
  14. #include "gem.h"
  15.  
  16.  
  17. /*
  18.  * special graphic funkcions
  19. */
  20. void v_bit_image(int handle, char *filename, int aspect, int x_scale,
  21.                         int y_scale, int h_align, int v_align,    int *pxyarray)
  22. {
  23.     short n;
  24.  
  25.     vdi_intin[0] = aspect;
  26.     vdi_intin[1] = x_scale;
  27.     vdi_intin[2] = y_scale;
  28.     vdi_intin[3] = h_align;
  29.     vdi_intin[4] = v_align;
  30.     n = vdi_str2array(filename, vdi_intin+5);
  31.     vdi_ptsin[0] = pxyarray[0];
  32.     vdi_ptsin[1] = pxyarray[1];
  33.     vdi_ptsin[2] = pxyarray[2];
  34.     vdi_ptsin[3] = pxyarray[3];
  35.     
  36.     vdi_control[0] = 5;
  37.     vdi_control[1] = 2;
  38.     vdi_control[3] = n + 5;
  39.     vdi_control[5] = 23;
  40.     vdi_control[6] = handle;
  41.     vdi(&vdi_params);
  42. }
  43.  
  44. void v_clear_disp_list(int handle)
  45. {
  46.     vdi_control[0] = 5;
  47.     vdi_control[1] = 0;
  48.     vdi_control[3] = 0;
  49.     vdi_control[5] = 22;
  50.     vdi_control[6] = handle;
  51.     vdi(&vdi_params);
  52. }
  53.  
  54. int v_copies(int handle, int count)
  55. {
  56.     vdi_intin[0] = count;
  57.     vdi_control[0] = 5;
  58.     vdi_control[1] = 0;
  59.     vdi_control[3] = 1;
  60.     vdi_control[5] = 28;
  61.     vdi_control[6] = handle;
  62.     vdi(&vdi_params);
  63.     return vdi_intout[0];
  64. } 
  65.  
  66. void v_dspcur(int handle, int x, int y)
  67. {
  68.     vdi_ptsin[0] = x;
  69.     vdi_ptsin[1] = y;
  70.     vdi_control[0] = 5;
  71.     vdi_control[1] = 1;
  72.     vdi_control[3] = 0;
  73.     vdi_control[5] = 18;
  74.     vdi_control[6] = handle;
  75.     vdi(&vdi_params);
  76. }
  77.  
  78. void v_form_adv(int handle)
  79. {
  80.     vdi_control[0] = 5;
  81.     vdi_control[1] = 0;
  82.     vdi_control[3] = 0;
  83.     vdi_control[5] = 20;
  84.     vdi_control[6] = handle;
  85.     vdi(&vdi_params);
  86. }
  87.  
  88. void v_hardcopy(int handle)
  89. {
  90.     vdi_control[0] = 5;
  91.     vdi_control[1] = 0;
  92.     vdi_control[3] = 0;
  93.     vdi_control[5] = 17;
  94.     vdi_control[6] = handle;
  95.     vdi(&vdi_params);
  96. }
  97.  
  98. int v_orient(int handle, int orientation)
  99. {
  100.     vdi_intin[0] = orientation;
  101.     vdi_control[0] = 5;
  102.     vdi_control[1] = 0;
  103.     vdi_control[3] = 1;
  104.     vdi_control[5] = 27;
  105.     vdi_control[6] = handle;
  106.     vdi(&vdi_params);
  107.     return vdi_intout[0];
  108. } 
  109.  
  110. void v_output_window(int handle, int *pxyarray)
  111. {
  112.     vdi_ptsin[0] = pxyarray[0];
  113.     vdi_ptsin[1] = pxyarray[1];
  114.     vdi_ptsin[2] = pxyarray[2];
  115.     vdi_ptsin[3] = pxyarray[3];
  116.     vdi_control[0] = 5;
  117.     vdi_control[1] = 2;
  118.     vdi_control[3] = 0;
  119.     vdi_control[5] = 21;
  120.     vdi_control[6] = handle;
  121.     vdi(&vdi_params);
  122. }
  123.  
  124. int v_page_size(int handle, int page_id)
  125. {
  126.     vdi_intin[0] = page_id;
  127.     vdi_control[0] = 5;
  128.     vdi_control[1] = 0;
  129.     vdi_control[3] = 1;
  130.     vdi_control[5] = 37;
  131.     vdi_control[6] = handle;
  132.     vdi(&vdi_params);
  133.     return vdi_intout[0]; 
  134. } 
  135.  
  136. void v_rmcur(int handle)
  137. {
  138.     vdi_control[0] = 5;
  139.     vdi_control[1] = 0;
  140.     vdi_control[3] = 0;
  141.     vdi_control[5] = 19;
  142.     vdi_control[6] = handle;
  143.     vdi(&vdi_params);
  144. }
  145.  
  146. void v_trays(int handle, int input, int output, int *set_input, int *set_output)
  147. {
  148.     vdi_intin[0] = input;
  149.     vdi_intin[1] = output;
  150.     vdi_control[0] = 5;
  151.     vdi_control[1] = 0;
  152.     vdi_control[3] = 2;
  153.     vdi_control[5] = 29;
  154.     vdi_control[6] = handle;
  155.     vdi(&vdi_params);
  156.     *set_input  = vdi_intout[0];
  157.     *set_output = vdi_intout[1];
  158. } 
  159.  
  160. int vq_calibrate (int handle, int *flag)
  161. {
  162.     vdi_control[0] = 5;
  163.     vdi_control[1] = 0;
  164.     vdi_control[3] = 1;
  165.     vdi_control[5] = 77;
  166.     vdi_control[6] = handle;
  167.     vdi(&vdi_params);
  168.     *flag = vdi_intout[0];
  169.     return vdi_control[4];
  170. } 
  171.  
  172. int vq_page_name(int handle, int page_id, char *page_name, long *page_width, long *page_height)
  173. {
  174.     vdi_intin[0] = page_id;
  175.     *((char **)(&vdi_intin[1])) = page_name;
  176.     vdi_control[0] = 5;
  177.     vdi_control[1] = 0;
  178.     vdi_control[3] = 3;
  179.     vdi_control[5] = 38;
  180.     vdi_control[6] = handle;
  181.     vdi(&vdi_params);
  182.     *page_width  = *((long *)(&vdi_intout[1]));
  183.     *page_height = *((long *)(&vdi_intout[3])); 
  184.     return vdi_intout[0];
  185. } 
  186.  
  187. void vq_scan(int handle, int *g_slice, int *g_page, int *a_slice, int *a_page, int *div_fac)
  188. {
  189.     vdi_control[0] = 5;
  190.     vdi_control[1] = 0;
  191.     vdi_control[3] = 0;
  192.     vdi_control[5] = 24;
  193.     vdi_control[6] = handle;
  194.     vdi(&vdi_params);
  195.     *g_slice = vdi_intout[0];
  196.     *g_page  = vdi_intout[1];
  197.     *a_slice = vdi_intout[2];
  198.     *a_page  = vdi_intout[3];
  199.     *div_fac = vdi_intout[4];
  200. }
  201.  
  202. int vq_tabstatus(int handle)
  203. {
  204.     vdi_control[0] = 5;
  205.     vdi_control[1] = 0;
  206.     vdi_control[3] = 0;
  207.     vdi_control[5] = 16;
  208.     vdi_control[6] = handle;
  209.     vdi(&vdi_params);
  210.     return vdi_intout[0];
  211. }
  212.  
  213. void vq_tray_names(int handle, char *input_name, char *output_name, int *input, int *output)
  214. {
  215.     *((char **)(&vdi_intin[0])) = input_name;
  216.     *((char **)(&vdi_intin[2])) = output_name;
  217.     vdi_control[0] = 5;
  218.     vdi_control[1] = 0;
  219.     vdi_control[3] = 4;
  220.     vdi_control[5] = 36;
  221.     vdi_control[6] = handle;
  222.     vdi(&vdi_params);
  223.     *input = vdi_intout[0];
  224.     *output = vdi_intout[1]; 
  225. } 
  226.  
  227. int vs_calibrate (int handle, int flag, int *rgb)
  228. {
  229.     *((int **)(&vdi_intin[0])) = rgb;
  230.     vdi_intin[2] = flag;
  231.     vdi_control[0] = 5;
  232.     vdi_control[1] = 0;
  233.     vdi_control[3] = 3;
  234.     vdi_control[5] = 76;
  235.     vdi_control[6] = handle;
  236.     vdi(&vdi_params);
  237.     return vdi_intout[0];
  238. } 
  239.  
  240. int vs_palette( int handle, int palette)
  241. {
  242.     vdi_intin[0] = palette;
  243.     vdi_control[0] = 5;
  244.     vdi_control[1] = 0;
  245.     vdi_control[3] = 1;
  246.     vdi_control[5] = 60;
  247.     vdi_control[6] = handle;
  248.     vdi(&vdi_params);
  249.     return vdi_intout[0];
  250. }
  251.  
  252.  
  253. /*
  254.  * graphic table functions
  255. */
  256. void vq_tdimensions(int handle, int *xdimension, int *ydimension)
  257. {
  258.     vdi_control[0] = 5;
  259.     vdi_control[1] = 0;
  260.     vdi_control[3] = 0;
  261.     vdi_control[5] = 84;
  262.     vdi_control[6] = handle;
  263.     vdi(&vdi_params);
  264.     *xdimension = vdi_intout[0];
  265.     *ydimension = vdi_intout[1]; 
  266. } 
  267.  
  268. void vt_alignment(int handle, int dx, int dy)
  269. {
  270.     vdi_intin[0] = dx;
  271.     vdi_intin[1] = dy;
  272.     vdi_control[0] = 5;
  273.     vdi_control[1] = 0;
  274.     vdi_control[3] = 2;
  275.     vdi_control[5] = 85;
  276.     vdi_control[6] = handle;
  277.     vdi(&vdi_params);
  278. }
  279.  
  280. void vt_axis(int handle, int xres, int yres, int *xset, int *yset)
  281. {
  282.     vdi_intin[0] = xres;
  283.     vdi_intin[1] = yres;
  284.     vdi_control[0] = 5;
  285.     vdi_control[1] = 0;
  286.     vdi_control[3] = 2;
  287.     vdi_control[5] = 82;
  288.     vdi_control[6] = handle;
  289.     vdi(&vdi_params);
  290.     *xset = vdi_intout[0];
  291.     *yset = vdi_intout[1];
  292. }
  293.  
  294. void vt_origin(int handle, int xorigin, int yorigin)
  295. {
  296.     vdi_intin[0] = xorigin;
  297.     vdi_intin[1] = yorigin;
  298.     vdi_control[0] = 5;
  299.     vdi_control[1] = 0;
  300.     vdi_control[3] = 2;
  301.     vdi_control[5] = 83;
  302.     vdi_control[6] = handle;
  303.     vdi(&vdi_params);
  304. }
  305.  
  306. void vt_resolution( int handle, int xres, int yres, int *xset, int *yset)
  307. {
  308.     vdi_intin[0] = xres;
  309.     vdi_intin[1] = yres;
  310.     vdi_control[0] = 5;
  311.     vdi_control[1] = 0;
  312.     vdi_control[3] = 2;
  313.     vdi_control[5] = 81;
  314.     vdi_control[6] = handle;
  315.     vdi(&vdi_params);
  316.     *xset = vdi_intout[0];
  317.     *yset = vdi_intout[1];
  318. }
  319.  
  320.  
  321. /*
  322.  * metfile functions
  323. */
  324. void v_meta_extents(int handle, int min_x, int min_y, int max_x, int max_y)
  325. {
  326.     vdi_ptsin[0] = min_x;
  327.     vdi_ptsin[1] = min_y;
  328.     vdi_ptsin[2] = max_x;
  329.     vdi_ptsin[3] = max_y;
  330.     vdi_control[0] = 5;
  331.     vdi_control[1] = 2;
  332.     vdi_control[3] = 0;
  333.     vdi_control[5] = 98;
  334.     vdi_control[6] = handle;
  335.     vdi(&vdi_params);
  336. }
  337.  
  338. void v_write_meta(int handle, int numvdi_intin, int *avdi_intin, int num_ptsin, int *a_ptsin)
  339. {
  340. #ifdef __MSHORT__
  341.     vdi_params.intin = (short *) &avdi_intin[0];
  342.     vdi_params.ptsin = (short *) &a_ptsin[0];
  343. #else
  344.     register int i;
  345.  
  346.     for(i = 0; i < numvdi_intin; i++)
  347.         vdi_intin[i] = avdi_intin[i];
  348.  
  349.     for(i = 0; i < num_ptsin; i++)
  350.         vdi_ptsin[i] = a_ptsin[i];
  351. #endif
  352.     vdi_control[0] = 5;
  353.     vdi_control[1] = num_ptsin;
  354.     vdi_control[3] = numvdi_intin;
  355.     vdi_control[5] = 99;
  356.     vdi_control[6] = handle;
  357.     vdi(&vdi_params);
  358.  
  359. #ifdef __MSHORT__
  360.     vdi_params.intin = &vdi_intin[0]; 
  361.     vdi_params.ptsin = &vdi_ptsin[0]; 
  362. #endif
  363. }
  364.  
  365. void vm_coords(int handle, int llx, int lly, int urx, int ury)
  366. {
  367.     vdi_intin[0] = 1;
  368.     vdi_intin[1] = llx;
  369.     vdi_intin[2] = lly;
  370.     vdi_intin[3] = urx;
  371.     vdi_intin[4] = ury;
  372.     vdi_control[0] = 5;
  373.     vdi_control[1] = 0;
  374.     vdi_control[3] = 5;
  375.     vdi_control[5] = 99;
  376.     vdi_control[6] = handle;
  377.     vdi(&vdi_params);
  378. }
  379.  
  380. void vm_filename(int handle, char *filename)
  381. {
  382.     short n;
  383.  
  384.      n = vdi_str2array(filename, vdi_intin);
  385.     vdi_control[0] = 5;
  386.     vdi_control[1] = 0;
  387.     vdi_control[3] = n;
  388.     vdi_control[5] = 100;
  389.     vdi_control[6] = handle;
  390.     vdi(&vdi_params);
  391.  
  392. }
  393.  
  394. void vm_pagesize(int handle, int pgwidth, int pgheight)
  395. {
  396.     vdi_intin[0] = 0;
  397.     vdi_intin[1] = pgwidth;
  398.     vdi_intin[2] = pgheight;
  399.     vdi_control[0] = 5;
  400.     vdi_control[1] = 0;
  401.     vdi_control[3] = 3;
  402.     vdi_control[5] = 99;
  403.     vdi_control[6] = handle;
  404.     vdi(&vdi_params);
  405. }
  406.  
  407.  
  408. /*
  409.  * polaroid functions - not complete implemented!
  410. */
  411. void vsc_expose(int handle, int state)
  412. {
  413.     vdi_intin[0] = state;
  414.     vdi_control[0] = 5;
  415.     vdi_control[1] = 0;
  416.     vdi_control[3] = 1;
  417.     vdi_control[5] = 93;
  418.     vdi_control[6] = handle;
  419.     vdi(&vdi_params);
  420. }
  421.  
  422. void vsp_film(int handle, int index, int lightness)
  423. {
  424.     vdi_intin[0] = index;
  425.     vdi_intin[1] = lightness;
  426.     vdi_control[0] = 5;
  427.     vdi_control[1] = 0;
  428.     vdi_control[3] = 2;
  429.     vdi_control[5] = 91;
  430.     vdi_control[6] = handle;
  431.     vdi(&vdi_params);
  432. }
  433.  
  434.  
  435. /*
  436.  * special functions
  437. */
  438. void v_escape2000(int handle, int times)
  439. {
  440.     vdi_intin[0] = times;
  441.     vdi_control[0] = 5;
  442.     vdi_control[1] = 0;
  443.     vdi_control[3] = 1;
  444.     vdi_control[5] = 2000;
  445.     vdi_control[6] = handle;
  446.     vdi(&vdi_params);
  447. }
  448.  
  449.  
  450. /*
  451.  * text functions
  452. */
  453. void v_alpha_text(int handle, char *str)
  454. {
  455.     short    n;
  456.     
  457.     n = vdi_str2array(str, vdi_intin);
  458.     vdi_control[0] = 5;
  459.     vdi_control[1] = 0;
  460.     vdi_control[3] = n;
  461.     vdi_control[5] = 25;
  462.     vdi_control[6] = handle;
  463.     vdi(&vdi_params);
  464. }
  465.  
  466. void v_curdown(int handle)
  467. {
  468.     vdi_control[0] = 5;
  469.     vdi_control[1] = 0;
  470.     vdi_control[3] = 0;
  471.     vdi_control[5] = 5;
  472.     vdi_control[6] = handle;
  473.     vdi(&vdi_params);
  474. }
  475.  
  476. void v_curhome(int handle)
  477. {
  478.     vdi_control[0] = 5;
  479.     vdi_control[1] = 0;
  480.     vdi_control[3] = 0;
  481.     vdi_control[5] = 8;
  482.     vdi_control[6] = handle;
  483.     vdi(&vdi_params);
  484. }
  485.  
  486. void v_curleft(int handle)
  487. {
  488.     vdi_control[0] = 5;
  489.     vdi_control[1] = 0;
  490.     vdi_control[3] = 0;
  491.     vdi_control[5] = 7;
  492.     vdi_control[6] = handle;
  493.     vdi(&vdi_params);
  494. }
  495.  
  496. void v_curright(int handle)
  497. {
  498.     vdi_control[0] = 5;
  499.     vdi_control[1] = 0;
  500.     vdi_control[3] = 0;
  501.     vdi_control[5] = 6;
  502.     vdi_control[6] = handle;
  503.     vdi(&vdi_params);
  504. }
  505.  
  506. void v_curtext(int handle, char *str)
  507. {
  508.     short    i;
  509.     
  510.     i = vdi_str2array(str, vdi_intin);
  511.     vdi_control[0] = 5;
  512.     vdi_control[1] = 0;
  513.     vdi_control[3] = i;
  514.     vdi_control[5] = 12;
  515.     vdi_control[6] = handle;
  516.     vdi(&vdi_params);
  517. }
  518.  
  519. void v_curup(int handle)
  520. {
  521.     vdi_control[0] = 5;
  522.     vdi_control[1] = 0;
  523.     vdi_control[3] = 0;
  524.     vdi_control[5] = 4;
  525.     vdi_control[6] = handle;
  526.     vdi(&vdi_params);
  527. }
  528.  
  529. void v_eeol(int handle)
  530. {
  531.     vdi_control[0] = 5;
  532.     vdi_control[1] = 0;
  533.     vdi_control[3] = 0;
  534.     vdi_control[5] = 10;
  535.     vdi_control[6] = handle;
  536.     vdi(&vdi_params);
  537. }
  538.  
  539. void v_eeos(int handle)
  540. {
  541.     vdi_control[0] = 5;
  542.     vdi_control[1] = 0;
  543.     vdi_control[3] = 0;
  544.     vdi_control[5] = 9;
  545.     vdi_control[6] = handle;
  546.     vdi(&vdi_params);
  547. }
  548.  
  549. void v_enter_cur(int handle)
  550. {
  551.     vdi_control[0] = 5;
  552.     vdi_control[1] = 0;
  553.     vdi_control[3] = 0;
  554.     vdi_control[5] = 3;
  555.     vdi_control[6] = handle;
  556.     vdi(&vdi_params);
  557. }
  558.  
  559. void v_exit_cur(int handle)
  560. {
  561.     vdi_control[0] = 5;
  562.     vdi_control[1] = 0;
  563.     vdi_control[3] = 0;
  564.     vdi_control[5] = 2;
  565.     vdi_control[6] = handle;
  566.     vdi(&vdi_params);
  567. }
  568.  
  569. void v_rvoff(int handle)
  570. {
  571.     vdi_control[0] = 5;
  572.     vdi_control[1] = 0;
  573.     vdi_control[3] = 0;
  574.     vdi_control[5] = 14;
  575.     vdi_control[6] = handle;
  576.     vdi(&vdi_params);
  577. }
  578.  
  579. void v_rvon(int handle)
  580. {
  581.     vdi_control[0] = 5;
  582.     vdi_control[1] = 0;
  583.     vdi_control[3] = 0;
  584.     vdi_control[5] = 13;
  585.     vdi_control[6] = handle;
  586.     vdi(&vdi_params);
  587. }
  588.  
  589. void vq_chcells(int handle, int *n_rows, int *n_cols)
  590. {
  591.     vdi_control[0] = 5;
  592.     vdi_control[1] = 0;
  593.     vdi_control[3] = 0;
  594.     vdi_control[5] = 1;
  595.     vdi_control[6] = handle;
  596.     vdi(&vdi_params);
  597.     *n_rows = vdi_intout[0];
  598.     *n_cols = vdi_intout[1];
  599. }
  600.  
  601. void vq_curaddress(int handle, int *cur_row, int *cur_col)
  602. {
  603.     vdi_control[0] = 5;
  604.     vdi_control[1] = 0;
  605.     vdi_control[3] = 0;
  606.     vdi_control[5] = 15;
  607.     vdi_control[6] = handle;
  608.     vdi(&vdi_params);
  609.     *cur_row = vdi_intout[0];
  610.     *cur_col = vdi_intout[1];
  611. }
  612.  
  613. void vs_curaddress(int handle, int row, int col)
  614. {
  615.     vdi_intin[0] = row;
  616.     vdi_intin[1] = col;
  617.     vdi_control[0] = 5;
  618.     vdi_control[1] = 0;
  619.     vdi_control[3] = 2;
  620.     vdi_control[5] = 11;
  621.     vdi_control[6] = handle;
  622.     vdi(&vdi_params);
  623. }
  624.